Процессы и потоки (нити)

План лекции

1. Понятие процесса и потока

2. Модели процессов и потоков

3. Реализация потоков в ядре и в пространстве пользователя

4. Взаимодействие процессов (IPC)

5. Межпроцессное взаимодействие: каналы, очереди сообщений, разделяемая память

6. Практические примеры

1. Понятие процесса

Процесс — экземпляр программы во время выполнения.

Компоненты процесса:

• Исполняемый код (текстовый сегмент)
• Данные (глобальные переменные, куча)
• Стек вызовов функций
• Содержимое регистров процессора
• Открытые файлы и другие ресурсы ОС

Что содержит PCB (Process Control Block)

Понятие потока (нити)

Поток (Thread) — наименьшая единица выполнения внутри процесса.

• Потоки одного процесса разделяют адресное пространство
• Каждый поток имеет свой собственный:
  • Стек
  • Счётчик команд (PC)
  • Набор регистров
• Потоки обеспечивают параллелизм внутри одного процесса

Процесс vs Поток

2. Однопоточный и многопоточный процесс

Однопоточный процесс:

• Один поток выполнения
• Последовательное выполнение инструкций

Многопоточный процесс:

• Несколько потоков внутри одного процесса
• Параллельное выполнение задач
• Разделение ресурсов между потоками
• Примеры: веб-сервер, браузер, IDE

Визуализация многопоточного процесса

3. Модели отображения потоков

Три основные модели:

1. Многие к одному — несколько пользовательских потоков → один поток ядра
2. Один к одному — каждый пользовательский поток → свой поток ядра
3. Многие ко многим — $n$ пользовательских потоков → $m$ потоков ядра ($m \le n$)

Выбор модели влияет на производительность и переносимость.

Модель «Многие к одному»

• Все потоки пользователя отображаются на один поток ядра
• Переключение потоков — быстрое (в пользовательском пространстве)
• Блокировка одного потока → блокирует весь процесс
• ОС не знает о существовании потоков
• Пример: ранние реализации POSIX threads (GNU Portable Threads)

Модель «Один к одному»

• Каждый пользовательский поток → отдельный поток ядра
• Истинный параллелизм на нескольких процессорах
• Блокировка одного потока не блокирует другие
• Большее потребление ресурсов
• Ограничение на число потоков
• Примеры: Windows, Linux (NPTL)

Модель «Многие ко многим»

• $n$ пользовательских потоков отображаются на $m$ потоков ядра ($m \le n$)
• Гибкость: ядро может создавать столько потоков, сколько нужно
• Комбинирует преимущества двух предыдущих моделей
• Сложнее в реализации
• Вариант: двухуровневая модель (многие ко многим + один к одному)
• Пример: Solaris (до версии 9)

Сравнение моделей потоков

Преимущества многопоточности

• Отзывчивость — интерфейс не «зависает» при длительных операциях
• Разделение ресурсов — потоки естественно разделяют память
• Экономичность — создание потока дешевле создания процесса
• Масштабируемость — использование многоядерных процессоров
• Быстрое переключение — меньше накладных расходов

Потоки POSIX (pthread)

Стандарт POSIX Threads (pthread) — API для работы с потоками:

• pthread_create() — создание потока
• pthread_join() — ожидание завершения потока
• pthread_exit() — завершение потока
• pthread_mutex_lock/unlock() — взаимное исключение
• pthread_cond_wait/signal() — условные переменные

4. Реализация потоков в пространстве пользователя

Потоки уровня пользователя (user-level threads):

• Библиотека управляет потоками (ядро «не видит» их)
• Переключение — очень быстрое (нет системного вызова)
• Не требуется поддержка от ядра ОС
• Проблема: блокировка одного потока → блокирует весь процесс
• Планирование — кооперативное или вытеснительное внутри библиотеки

Проблемы потоков уровня пользователя

• Системный вызов блокирует все потоки процесса
• Ядро не может передать квант времени другому потоку
• Невозможно использовать несколько процессоров
• Сложно реализовать read() без блокировки
• Решение: обёртки (wrappers) для системных вызовов или неблокирующий I/O

Потоки уровня ядра (kernel-level threads)

Потоки ядра:

• Управляются непосредственно ядром ОС
• Ядро знает о каждом потоке и планирует его
• Параллельное выполнение на нескольких процессорах
• Блокировка одного потока — другие продолжают работу
• Недостаток: большее время переключения (системный вызов)
• Примеры: Windows threads, Linux pthreads (NPTL)

Сравнение пользовательских и ядерных потоков

Гибридные модели

• Комбинация потоков пользователя и ядра
• Ядро предоставляет несколько $k$-потоков
• Библиотека распределяет $u$-потоки по $k$-потокам ($u > k$)
• Баланс между производительностью и параллелизмом
• Пример: NetBSD saffinity, старые версии Solaris

Системный вызов Linux: clone()

В Linux и процессы, и потоки создаются через clone():

• fork() — полное копирование адресного пространства
• clone() — выборочное разделение ресурсов:
  • CLONE_VM — разделить память (→ поток)
  • CLONE_FS — разделить информацию о файловой системе
  • CLONE_FILES — разделить таблицу файловых дескрипторов
  • CLONE_SIGHAND — разделить обработчики сигналов

fork() vs clone()

Задачи в Linux (Tasks)

• В Linux нет отдельного понятия «поток» и «процесс»
• Всё — задачи (tasks), описываемые task_struct
• Потоки — задачи с общным адресным пространством
• Каждый поток имеет свой tid (Thread ID)
• getpid() у всех потоков возвращает один PID
• gettid() возвращает уникальный идентификатор потока

5. Взаимодействие процессов (IPC)

IPC — Inter-Process Communication

Зачем нужно взаимодействие процессов?

• Передача данных между процессами
• Синхронизация доступа к ресурсам
• Координация выполнения

Две основные модели:

• Разделяемая память — быстрая, но требует синхронизации
• Передача сообщений — безопаснее, но медленнее

Классификация механизмов IPC

Синхронизация vs Коммуникация

• Коммуникация — обмен данными между процессами
• Синхронизация — координация порядка выполнения
• Некоторые механизмы обеспечивают и то, и другое
• Пример: семафор — синхронизация, канал — коммуникация + синхронизация

IPC: System V и POSIX

6. Каналы (Pipes)

Неименованный канал (anonymous pipe):

• Однонаправленный поток байтов
• Создаётся pipe(fd[2])
• fd[0] — чтение, fd[1] — запись
• Работает только между родственными процессами (fork)
• После fork() — родитель пишет, дочерний читает (или наоборот)

Пример: неименованный канал

#include <unistd.h>
#include <string.h>
#include <stdio.h>

int main() {
    int fd[2];
    pid_t pid;
    char buf[128];

    pipe(fd);
    pid = fork();

    if (pid == 0) {
        close(fd[1]);
        read(fd[0], buf, sizeof(buf));
        printf("Child got: %s\n", buf);
        close(fd[0]);
    } else {
        close(fd[0]);
        write(fd[1], "Hello", 6);
        close(fd[1]);
    }
    return 0;
}

Именованные каналы (FIFO)

• Имя в файловой системе (mkfifo())
• Могут взаимодействовать любые процессы (не только родственные)
• Двунаправленное взаимодействие (через два FIFO)
• Персистентны — существуют до удаления (unlink)

mkfifo("/tmp/myfifo", 0666);
int fd = open("/tmp/myfifo", O_WRONLY);
write(fd, "Hello", 6);
close(fd);

Очереди сообщений

• Структурированные сообщения (тип + данные)
• Процесс может читать сообщения определённого типа
• Асинхронная передача — отправитель не ждёт получателя
• Сообщения сохраняются до чтения

System V: msgget(), msgsnd(), msgrcv()
POSIX: mq_open(), mq_send(), mq_receive()

Разделяемая память

Самый быстрый механизм IPC — прямое отображение памяти в адресные пространства нескольких процессов.

• Нет копирования данных (в отличие от каналов и сообщений)
• Процессы работают с одним и тем же участком памяти
• Требует синхронизации (гонки данных!)
• shmget() — создание сегмента (System V)
• shmat() — подключение сегмента к адресному пространству

Пример: разделяемая память (System V)

#include <sys/shm.h>
#include <string.h>
#include <stdio.h>

int main() {
    int shmid = shmget(1234, 1024, IPC_CREAT | 0666);
    char *shm = (char *)shmat(shmid, NULL, 0);

    strcpy(shm, "Hello from shared memory!");
    printf("Data: %s\n", shm);

    shmdt(shm);
    return 0;
}

mmap — отображение файла в память

#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>

int main() {
    int fd = open("/tmp/mmfile", O_RDWR | O_CREAT, 0666);
    ftruncate(fd, 4096);
    char *p = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
                   MAP_SHARED, fd, 0);
    strcpy(p, "Hello via mmap!");
    printf("%s\n", p);
    munmap(p, 4096);
    close(fd);
    return 0;
}

Семафоры

• Примитив синхронизации доступа к разделяемым ресурсам
• Счётчик с атомарными операциями:
  • wait() (P) — уменьшить; если $< 0$ — заблокировать
  • signal() (V) — увеличить; разбудить ожидающий процесс
• System V: semget(), semop()
• POSIX: sem_open(), sem_wait(), sem_post()
• Подробно — в лекции 07 (Синхронизация)

Сигналы

• Асинхронные уведомления процессов
• Посылаются ядром или другим процессом
• Стандартные сигналы: SIGINT, SIGTERM, SIGKILL, SIGSEGV
• Обработчик сигнала: signal() или sigaction()
• Можно использовать для простой IPC (SIGUSR1, SIGUSR2)
• Ограничение: минимальная передача данных (только факт сигнала)

Сокеты

• Двунаправленный канал связи
• Работают как локально, так и по сети
• Типы: SOCK_STREAM (TCP), SOCK_DGRAM (UDP)
• Unix domain sockets — для локальной IPC
• Универсальный, но более медленный механизм

Пример: создание потоков (pthread)

#include <pthread.h>
#include <stdio.h>

void *worker(void *arg) {
    long id = (long)arg;
    printf("Thread %ld running\n", id);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, worker, (void *)1);
    pthread_create(&t2, NULL, worker, (void *)2);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    return 0;
}

Паттерн Producer-Consumer

• Классический паттерн многопоточного программирования
• Producer — генерирует данные, помещает в буфер
• Consumer — извлекает данные из буфера и обрабатывает
• Требует синхронизации доступа к буферу
• Реализация: мьютекс + условная переменная (или семафоры)

Паттерн Thread Pool

• Заранее создаётся пул ($N$) рабочих потоков
• Задачи поступают в очередь
• Свободный поток берёт задачу из очереди
• Преимущества:
  • Ограниченное число потоков
  • Нет накладных расходов на создание/уничтожение
  • Предсказуемая нагрузка на систему

Паттерн Fork-Join

• Fork — разделение задачи на подзадачи (создание потоков)
• Параллельное выполнение подзадач
• Join — ожидание завершения всех потоков, сбор результатов
• Пример: параллельная обработка элементов массива

main thread
   |
   +-- fork --> thread 1 --> join --+
   +-- fork --> thread 2 --> join --+--> continue
   +-- fork --> thread 3 --> join --+

Сводная таблица механизмов IPC

Заключение

Ключевые выводы лекции

Вопросы для самоконтроля

1. Чем отличается процесс от потока?
2. Какие ресурсы разделяют потоки одного процесса?
3. Какие существуют модели отображения потоков пользователя на потоки ядра?
4. В чём преимущества и недостатки потоков уровня пользователя?
5. В чём преимущества и недостатки потоков уровня ядра?
6. Как реализованы потоки в Linux (clone)?
7. Перечислите основные механизмы межпроцессного взаимодействия.
8. В чём разница между именованными и неименованными каналами?
9. Какие преимущества даёт разделяемая память по сравнению с другими механизмами IPC?
10. Что такое pthread и какие основные функции она предоставляет?

Рекомендуемые ресурсы